﻿Imports Microsoft.DirectX
Imports Microsoft.DirectX.Direct3D
Imports Commander_Wars.Spieletools
Public MustInherit Class ObjektLandschaftsTextur
    Const YLayer As Single = 0.015

    Public Enum Positionsarten
        Boden
        Luft
        Wasser
    End Enum
    Private IDD As String
    Public Property ID() As String
        Get
            Return IDD
        End Get
        Set(ByVal value As String)
            IDD = value
        End Set
    End Property
    Public Landschaftsname As String
    Public Deckung As Integer = 0
    Public Tarnung As Boolean = False
    Public KP As Integer = -1
    Public Texturen() As Texture = {}
    Protected Ausrichtung() As String = {}
    Protected Normal As Integer
    Protected Ausrichtungslandschaften() As String = {}
    Protected SekundärAusrichtungslandschaften() As String = {}
    Public Uebergaenge() As Texture = {}
    Public Uebergangfunktion() As String = {}
    Public UebergangsModus As Uebergangsmodi = Uebergangsmodi.Keiner
    Public DrawUebergaenge As Boolean = True
    Dim UebergangsAusrichtungslandschaften() As String = {}
    Public WirdZu As String
    Public Gross As Boolean = False
    Public Frame As Boolean = False
    Public Shared WuestenID As Integer = -1
    Public Shared EbenenID As Integer = -1
    Public Shared SeeID As Integer = -1
    Public Shared SchneeID As Integer = -1

    Enum Uebergangsmodi
        Keiner
        VierAngrenzenden
        NichtVierAngrenzenden
        NurEcken
        NichtNurEcken
        Strand
    End Enum

    Protected Sub TexturenLaden(ByVal Bilder() As String)
        Dim Ordner As String = ObjektLadeklasse.GetOrdner
        For Each Bild In Bilder

            Array.Resize(Texturen, Texturen.Length + 1)
            Array.Resize(Ausrichtung, Ausrichtung.Length + 1)
            Dim Found As Boolean = False
            For Each Folder In My.Computer.FileSystem.GetDirectories(DataSettings.Resourcenpfad + "Terrain\Overworld\" + Ordner, FileIO.SearchOption.SearchTopLevelOnly)
                If My.Computer.FileSystem.FileExists(Folder + "\" + Bild + ".png") Then
                    Texturen(Texturen.Length - 1) = Grafikengine.LoadTexture(Folder + "\" + Bild + ".png")
                    Found = True
                    Exit For
                End If
            Next
            If Not Found Then
                If My.Computer.FileSystem.FileExists(DataSettings.Resourcenpfad + "Terrain\Overworld\" + Ordner + Bild + ".png") Then
                    Texturen(Texturen.Length - 1) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Overworld\" + Ordner + Bild + ".png")
                    Found = True
                End If
            End If
            If Not Found Then
                For Each Folder In My.Computer.FileSystem.GetDirectories(DataSettings.Resourcenpfad + "Terrain\Overworld\CW\", FileIO.SearchOption.SearchTopLevelOnly)
                    If My.Computer.FileSystem.FileExists(Folder + "\" + Bild + ".png") Then
                        Texturen(Texturen.Length - 1) = Grafikengine.LoadTexture(Folder + "\" + Bild + ".png")
                        Found = True
                        Exit For
                    End If
                Next
            End If

            If Not Found Then
                Texturen(Texturen.Length - 1) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Overworld\CW\" + Bild + ".png")
            End If
            If Bild.Contains("_") Then
                Dim Namen As String = Bild
                While Namen.StartsWith("_") = False And Namen.StartsWith("+") = False
                    Namen = Namen.Remove(0, 1)
                End While
                If Namen.StartsWith("+") Then Namen = Namen.Remove(0, 1)
                Ausrichtung(Ausrichtung.Length - 1) = Namen
            Else
                Dim Name() As String = Bild.Split("+")
                If Name.Length > 1 Then
                    If IsNumeric(Name(1)) = False Then
                        Dim Namen As String = ""
                        For I = 1 To Name.Length - 1
                            Namen += Name(I)
                            If I >= Name.Length - 1 Then
                                Ausrichtung(Ausrichtung.Length - 1) = Namen
                                Exit For
                            End If
                            Namen += "+"
                        Next
                    End If
                End If
            End If
        Next
    End Sub
#Region "Spezial Malen"
    Public Overridable Function DrawSpecialStyle(ByVal BildID As Integer, ByVal Fog As Nebelarten, ByVal Alpha As Integer, ByVal X As Integer, ByVal Y As Integer, ByVal TerrainUntergrundID As Integer, ByVal TerrainUntergrundBildID As Integer, ByVal TerrainUntergrundID2 As Integer, ByVal TerrainUntergrundBildID2 As Integer, Optional ByVal FixedLocation As Boolean = False, Optional ByVal Top As Boolean = False) As Boolean
        Return False
    End Function
    Protected Function DrawSeeUndTerrain(ByVal Alpha As Integer, ByVal Kriegsnebel As Nebelarten, ByVal BildId As Integer, ByVal X As Integer, ByVal Y As Integer, ByVal Frames As Integer, ByVal MaxFrames As Integer) As Boolean
        If DataSettings._2D_3D_Malen Then
            Dim intColor As Color = Color.FromArgb(Alpha, 255, 255, 255)
            'pruefen ob wir aus den Screenbereich laufen
            Select Case Kriegsnebel
                Case Nebelarten.Nebel
                    intColor = Color.FromArgb(Alpha, 180, 180, 180)
                Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                    intColor = Color.FromArgb(Alpha, 120, 120, 120)
            End Select
            'Zuerst See
            Dim Hoehe As Integer = 0
            Dim Breite As Single = 1
            Dim BreiteStart As Single = 0
            If Objektverwalter.LandschaftenBilder(SeeID).Frame Then
                Breite = 0.25
                BreiteStart = Frame / 4
            End If

            Dim cube(3) As CustomVertex.PositionTextured
            cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart, 1)
            cube(1) = New CustomVertex.PositionTextured(0, 0, 1 + Hoehe, BreiteStart, 0)
            cube(2) = New CustomVertex.PositionTextured(1, 0, 0, BreiteStart + Breite, 1)
            cube(3) = New CustomVertex.PositionTextured(1, 0, 1 + Hoehe, BreiteStart + Breite, 0)
            Grafikengine.malen2Din3D(ObjektSpielfeld.CalcDraw2D3DVec(X, ObjektSpielfeld.SpielfeldLayer.LandschaftenUntergrund, Y), cube, Objektverwalter.LandschaftenBilder(SeeID).Texturen(0), intColor)
            'Dann Terrain
            Hoehe = 0
            Breite = 1
            BreiteStart = 0
            If Gross Then
                Hoehe = 1
            End If
            If MaxFrames > 0 Then
                Breite = 1 / MaxFrames
                BreiteStart = Frames / MaxFrames
            End If

            ReDim cube(3)
            cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart, 1)
            cube(1) = New CustomVertex.PositionTextured(0, 0, 1 + Hoehe, BreiteStart, 0)
            cube(2) = New CustomVertex.PositionTextured(1, 0, 0, BreiteStart + Breite, 1)
            cube(3) = New CustomVertex.PositionTextured(1, 0, 1 + Hoehe, BreiteStart + Breite, 0)
            Grafikengine.malen2Din3D(ObjektSpielfeld.CalcDraw2D3DVec(X, ObjektSpielfeld.SpielfeldLayer.Landschaften, Y), cube, Texturen(BildId), intColor)

        Else
            Dim sngRotation As Double = 0
            Dim intColor As Color = Color.FromArgb(Alpha, 255, 255, 255)
            'pruefen ob wir aus den Screenbereich laufen
            Select Case Kriegsnebel
                Case Nebelarten.Nebel
                    intColor = Color.FromArgb(Alpha, 180, 180, 180)
                Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                    intColor = Color.FromArgb(Alpha, 120, 120, 120)
            End Select
            'Zuerst See Malen
            With Grafikengine.recBild
                .X = 0 : .Width = Hauptmenue.Feldbreite
                .Y = 0 : .Height = Hauptmenue.Feldbreite
            End With
            With Grafikengine.ptfRotCenter
                .X = Hauptmenue.Feldbreite / 2
                .Y = Hauptmenue.Feldbreite / 2
            End With
            With Grafikengine.szfScale
                .Height = Hauptmenue.Feldbreite
                .Width = Hauptmenue.Feldbreite
            End With
            If Objektverwalter.LandschaftenBilder(SeeID).Frame Then
                Grafikengine.recBild.X += ObjektLandschaft.Frame * Hauptmenue.Feldbreite
            End If
            Grafikengine.ptfPosition = New Drawing.Point(Hauptmenue.Feldbreite * X + Objektverwalter.Spielfeld.BildschirmKooX, Hauptmenue.Feldbreite * Y + Objektverwalter.Spielfeld.BildschirmKooY)
            Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(SeeID).Texturen(0), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)

            If Gross = False Then
                With Grafikengine.recBild
                    .X = 0 : .Width = Hauptmenue.Feldbreite
                    .Y = 0 : .Height = Hauptmenue.Feldbreite
                End With
                With Grafikengine.ptfRotCenter
                    .X = Hauptmenue.Feldbreite / 2
                    .Y = Hauptmenue.Feldbreite / 2
                End With
                With Grafikengine.szfScale
                    .Height = Hauptmenue.Feldbreite
                    .Width = Hauptmenue.Feldbreite
                End With
            Else
                With Grafikengine.recBild
                    .X = 0 : .Width = Hauptmenue.Feldbreite
                    .Y = 0 : .Height = Hauptmenue.Feldbreite * 2
                End With
                With Grafikengine.ptfRotCenter
                    .X = Hauptmenue.Feldbreite / 2
                    .Y = Hauptmenue.Feldbreite / 2 + Hauptmenue.Feldbreite
                End With
                With Grafikengine.szfScale
                    .Height = Hauptmenue.Feldbreite * 2
                    .Width = Hauptmenue.Feldbreite
                End With
            End If

            Grafikengine.recBild.X += Frames * Hauptmenue.Feldbreite
            Grafikengine.Sprite.Draw2D(Texturen(BildId), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
        End If
        Return True
    End Function
    Protected Function DrawEbeneUndTerrain(ByVal Alpha As Integer, ByVal Kriegsnebel As Nebelarten, ByVal BildId As Integer, ByVal X As Integer, ByVal Y As Integer, ByVal Frames As Integer, ByVal MaxFrames As Integer) As Boolean
        If DataSettings._2D_3D_Malen Then
            Dim intColor As Color = Color.FromArgb(Alpha, 255, 255, 255)
            'pruefen ob wir aus den Screenbereich laufen
            Select Case Kriegsnebel
                Case Nebelarten.Nebel
                    intColor = Color.FromArgb(Alpha, 180, 180, 180)
                Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                    intColor = Color.FromArgb(Alpha, 120, 120, 120)
            End Select
            'Zuerst See
            Dim Hoehe As Integer = 0
            Dim Breite As Single = 1
            Dim BreiteStart As Single = 0
            If Objektverwalter.LandschaftenBilder(EbenenID).Frame Then
                Breite = 0.25
                BreiteStart = Frame / 4
            End If

            Dim cube(3) As CustomVertex.PositionTextured
            cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart, 1)
            cube(1) = New CustomVertex.PositionTextured(0, 0, 1 + Hoehe, BreiteStart, 0)
            cube(2) = New CustomVertex.PositionTextured(1, 0, 0, BreiteStart + Breite, 1)
            cube(3) = New CustomVertex.PositionTextured(1, 0, 1 + Hoehe, BreiteStart + Breite, 0)
            Grafikengine.malen2Din3D(ObjektSpielfeld.CalcDraw2D3DVec(X, ObjektSpielfeld.SpielfeldLayer.LandschaftenUntergrund, Y), cube, Objektverwalter.LandschaftenBilder(EbenenID).Texturen(0), intColor)
            'Dann Terrain
            Hoehe = 0
            Breite = 1
            BreiteStart = 0
            If Gross Then
                Hoehe = 1
            End If
            If MaxFrames > 0 Then
                Breite = 1 / MaxFrames
                BreiteStart = Frames / MaxFrames
            End If

            ReDim cube(3)
            cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart, 1)
            cube(1) = New CustomVertex.PositionTextured(0, 0, 1 + Hoehe, BreiteStart, 0)
            cube(2) = New CustomVertex.PositionTextured(1, 0, 0, BreiteStart + Breite, 1)
            cube(3) = New CustomVertex.PositionTextured(1, 0, 1 + Hoehe, BreiteStart + Breite, 0)
            Grafikengine.malen2Din3D(ObjektSpielfeld.CalcDraw2D3DVec(X, ObjektSpielfeld.SpielfeldLayer.Landschaften, Y), cube, Texturen(BildId), intColor)

        Else
            Dim sngRotation As Double = 0
            Dim intColor As Color = Color.FromArgb(Alpha, 255, 255, 255)
            'pruefen ob wir aus den Screenbereich laufen
            Select Case Kriegsnebel
                Case Nebelarten.Nebel
                    intColor = Color.FromArgb(Alpha, 180, 180, 180)
                Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                    intColor = Color.FromArgb(Alpha, 120, 120, 120)
            End Select
            'Zuerst See Malen
            With Grafikengine.recBild
                .X = 0 : .Width = Hauptmenue.Feldbreite
                .Y = 0 : .Height = Hauptmenue.Feldbreite
            End With
            With Grafikengine.ptfRotCenter
                .X = Hauptmenue.Feldbreite / 2
                .Y = Hauptmenue.Feldbreite / 2
            End With
            With Grafikengine.szfScale
                .Height = Hauptmenue.Feldbreite
                .Width = Hauptmenue.Feldbreite
            End With
            If Objektverwalter.LandschaftenBilder(EbenenID).Frame Then
                Grafikengine.recBild.X += ObjektLandschaft.Frame * Hauptmenue.Feldbreite
            End If
            Grafikengine.ptfPosition = New Drawing.Point(Hauptmenue.Feldbreite * X + Objektverwalter.Spielfeld.BildschirmKooX, Hauptmenue.Feldbreite * Y + Objektverwalter.Spielfeld.BildschirmKooY)
            Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(EbenenID).Texturen(0), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)

            If Gross = False Then
                With Grafikengine.recBild
                    .X = 0 : .Width = Hauptmenue.Feldbreite
                    .Y = 0 : .Height = Hauptmenue.Feldbreite
                End With
                With Grafikengine.ptfRotCenter
                    .X = Hauptmenue.Feldbreite / 2
                    .Y = Hauptmenue.Feldbreite / 2
                End With
                With Grafikengine.szfScale
                    .Height = Hauptmenue.Feldbreite
                    .Width = Hauptmenue.Feldbreite
                End With
            Else
                With Grafikengine.recBild
                    .X = 0 : .Width = Hauptmenue.Feldbreite
                    .Y = 0 : .Height = Hauptmenue.Feldbreite * 2
                End With
                With Grafikengine.ptfRotCenter
                    .X = Hauptmenue.Feldbreite / 2
                    .Y = Hauptmenue.Feldbreite / 2 + Hauptmenue.Feldbreite
                End With
                With Grafikengine.szfScale
                    .Height = Hauptmenue.Feldbreite * 2
                    .Width = Hauptmenue.Feldbreite
                End With
            End If
            Grafikengine.recBild.X += Frames * Hauptmenue.Feldbreite
            Grafikengine.Sprite.Draw2D(Texturen(BildId), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
        End If
        Return True
    End Function
    Protected Function DrawWuesteUndTerrain(ByVal Alpha As Integer, ByVal Kriegsnebel As Nebelarten, ByVal BildId As Integer, ByVal X As Integer, ByVal Y As Integer, ByVal Frames As Boolean, ByVal MaxFrames As Integer) As Boolean
        If DataSettings._2D_3D_Malen Then
            Dim intColor As Color = Color.FromArgb(Alpha, 255, 255, 255)
            'pruefen ob wir aus den Screenbereich laufen
            Select Case Kriegsnebel
                Case Nebelarten.Nebel
                    intColor = Color.FromArgb(Alpha, 180, 180, 180)
                Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                    intColor = Color.FromArgb(Alpha, 120, 120, 120)
            End Select
            'Zuerst See
            Dim Hoehe As Integer = 0
            Dim Breite As Single = 1
            Dim BreiteStart As Single = 0
            If Objektverwalter.LandschaftenBilder(WuestenID).Frame Then
                Breite = 0.25
                BreiteStart = Frames / 4
            End If

            Dim cube(3) As CustomVertex.PositionTextured
            cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart, 1)
            cube(1) = New CustomVertex.PositionTextured(0, 0, 1 + Hoehe, BreiteStart, 0)
            cube(2) = New CustomVertex.PositionTextured(1, 0, 0, BreiteStart + Breite, 1)
            cube(3) = New CustomVertex.PositionTextured(1, 0, 1 + Hoehe, BreiteStart + Breite, 0)
            Grafikengine.malen2Din3D(ObjektSpielfeld.CalcDraw2D3DVec(X, ObjektSpielfeld.SpielfeldLayer.LandschaftenUntergrund, Y), cube, Objektverwalter.LandschaftenBilder(WuestenID).Texturen(0), intColor)
            'Dann Terrain
            Hoehe = 0
            Breite = 1
            BreiteStart = 0
            If Gross Then
                Hoehe = 1
            End If
            If MaxFrames > 0 Then
                Breite = 1 / MaxFrames
                BreiteStart = Frame / MaxFrames
            End If

            ReDim cube(3)
            cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart, 1)
            cube(1) = New CustomVertex.PositionTextured(0, 0, 1 + Hoehe, BreiteStart, 0)
            cube(2) = New CustomVertex.PositionTextured(1, 0, 0, BreiteStart + Breite, 1)
            cube(3) = New CustomVertex.PositionTextured(1, 0, 1 + Hoehe, BreiteStart + Breite, 0)
            Grafikengine.malen2Din3D(ObjektSpielfeld.CalcDraw2D3DVec(X, ObjektSpielfeld.SpielfeldLayer.Landschaften, Y), cube, Texturen(BildId), intColor)

        Else

            Dim sngRotation As Double = 0
            Dim intColor As Color = Color.FromArgb(Alpha, 255, 255, 255)
            'pruefen ob wir aus den Screenbereich laufen
            Select Case Kriegsnebel
                Case Nebelarten.Nebel
                    intColor = Color.FromArgb(Alpha, 180, 180, 180)
                Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                    intColor = Color.FromArgb(Alpha, 120, 120, 120)
            End Select
            'Zuerst See Malen
            With Grafikengine.recBild
                .X = 0 : .Width = Hauptmenue.Feldbreite
                .Y = 0 : .Height = Hauptmenue.Feldbreite
            End With
            With Grafikengine.ptfRotCenter
                .X = Hauptmenue.Feldbreite / 2
                .Y = Hauptmenue.Feldbreite / 2
            End With
            With Grafikengine.szfScale
                .Height = Hauptmenue.Feldbreite
                .Width = Hauptmenue.Feldbreite
            End With
            If Objektverwalter.LandschaftenBilder(WuestenID).Frame Then
                Grafikengine.recBild.X += ObjektLandschaft.Frame * Hauptmenue.Feldbreite
            End If
            Grafikengine.ptfPosition = New Drawing.Point(Hauptmenue.Feldbreite * X + Objektverwalter.Spielfeld.BildschirmKooX, Hauptmenue.Feldbreite * Y + Objektverwalter.Spielfeld.BildschirmKooY)
            Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(WuestenID).Texturen(0), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)

            If Gross = False Then
                With Grafikengine.recBild
                    .X = 0 : .Width = Hauptmenue.Feldbreite
                    .Y = 0 : .Height = Hauptmenue.Feldbreite
                End With
                With Grafikengine.ptfRotCenter
                    .X = Hauptmenue.Feldbreite / 2
                    .Y = Hauptmenue.Feldbreite / 2
                End With
                With Grafikengine.szfScale
                    .Height = Hauptmenue.Feldbreite
                    .Width = Hauptmenue.Feldbreite
                End With
            Else
                With Grafikengine.recBild
                    .X = 0 : .Width = Hauptmenue.Feldbreite
                    .Y = 0 : .Height = Hauptmenue.Feldbreite * 2
                End With
                With Grafikengine.ptfRotCenter
                    .X = Hauptmenue.Feldbreite / 2
                    .Y = Hauptmenue.Feldbreite / 2 + Hauptmenue.Feldbreite
                End With
                With Grafikengine.szfScale
                    .Height = Hauptmenue.Feldbreite * 2
                    .Width = Hauptmenue.Feldbreite
                End With
            End If
            If Frames Then
                Grafikengine.recBild.X += ObjektLandschaft.Frame * Hauptmenue.Feldbreite
            End If
            Grafikengine.Sprite.Draw2D(Texturen(BildId), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
        End If
        Return True
    End Function
    Protected Function DrawSchneeUndTerrain(ByVal Alpha As Integer, ByVal Kriegsnebel As Nebelarten, ByVal BildId As Integer, ByVal X As Integer, ByVal Y As Integer, ByVal Frames As Boolean, ByVal MaxFrames As Integer) As Boolean
        If DataSettings._2D_3D_Malen Then
            Dim intColor As Color = Color.FromArgb(Alpha, 255, 255, 255)
            'pruefen ob wir aus den Screenbereich laufen
            Select Case Kriegsnebel
                Case Nebelarten.Nebel
                    intColor = Color.FromArgb(Alpha, 180, 180, 180)
                Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                    intColor = Color.FromArgb(Alpha, 120, 120, 120)
            End Select
            'Zuerst See
            Dim Hoehe As Integer = 0
            Dim Breite As Single = 1
            Dim BreiteStart As Single = 0
            If Objektverwalter.LandschaftenBilder(SchneeID).Frame Then
                Breite = 0.25
                BreiteStart = Frame / 4
            End If

            Dim cube(3) As CustomVertex.PositionTextured
            cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart, 1)
            cube(1) = New CustomVertex.PositionTextured(0, 0, 1 + Hoehe, BreiteStart, 0)
            cube(2) = New CustomVertex.PositionTextured(1, 0, 0, BreiteStart + Breite, 1)
            cube(3) = New CustomVertex.PositionTextured(1, 0, 1 + Hoehe, BreiteStart + Breite, 0)
            Grafikengine.malen2Din3D(ObjektSpielfeld.CalcDraw2D3DVec(X, ObjektSpielfeld.SpielfeldLayer.LandschaftenUntergrund, Y), cube, Objektverwalter.LandschaftenBilder(SchneeID).Texturen(0), intColor)
            'Dann Terrain
            Hoehe = 0
            Breite = 1
            BreiteStart = 0
            If Gross Then
                Hoehe = 1
            End If
            If MaxFrames > 0 Then
                Breite = 1 / MaxFrames
                BreiteStart = Frames / MaxFrames
            End If

            ReDim cube(3)
            cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart, 1)
            cube(1) = New CustomVertex.PositionTextured(0, 0, 1 + Hoehe, BreiteStart, 0)
            cube(2) = New CustomVertex.PositionTextured(1, 0, 0, BreiteStart + Breite, 1)
            cube(3) = New CustomVertex.PositionTextured(1, 0, 1 + Hoehe, BreiteStart + Breite, 0)
            Grafikengine.malen2Din3D(ObjektSpielfeld.CalcDraw2D3DVec(X, ObjektSpielfeld.SpielfeldLayer.Landschaften, Y), cube, Texturen(BildId), intColor)

        Else
            Dim sngRotation As Double = 0
            Dim intColor As Color = Color.FromArgb(Alpha, 255, 255, 255)
            'pruefen ob wir aus den Screenbereich laufen
            Select Case Kriegsnebel
                Case Nebelarten.Nebel
                    intColor = Color.FromArgb(Alpha, 180, 180, 180)
                Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                    intColor = Color.FromArgb(Alpha, 120, 120, 120)
            End Select
            'Zuerst See Malen
            With Grafikengine.recBild
                .X = 0 : .Width = Hauptmenue.Feldbreite
                .Y = 0 : .Height = Hauptmenue.Feldbreite
            End With
            With Grafikengine.ptfRotCenter
                .X = Hauptmenue.Feldbreite / 2
                .Y = Hauptmenue.Feldbreite / 2
            End With
            With Grafikengine.szfScale
                .Height = Hauptmenue.Feldbreite
                .Width = Hauptmenue.Feldbreite
            End With
            If Objektverwalter.LandschaftenBilder(SchneeID).Frame Then
                Grafikengine.recBild.X += ObjektLandschaft.Frame * Hauptmenue.Feldbreite
            End If
            Grafikengine.ptfPosition = New Drawing.Point(Hauptmenue.Feldbreite * X + Objektverwalter.Spielfeld.BildschirmKooX, Hauptmenue.Feldbreite * Y + Objektverwalter.Spielfeld.BildschirmKooY)
            Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(SchneeID).Texturen(0), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)

            If Gross = False Then
                With Grafikengine.recBild
                    .X = 0 : .Width = Hauptmenue.Feldbreite
                    .Y = 0 : .Height = Hauptmenue.Feldbreite
                End With
                With Grafikengine.ptfRotCenter
                    .X = Hauptmenue.Feldbreite / 2
                    .Y = Hauptmenue.Feldbreite / 2
                End With
                With Grafikengine.szfScale
                    .Height = Hauptmenue.Feldbreite
                    .Width = Hauptmenue.Feldbreite
                End With
            Else
                With Grafikengine.recBild
                    .X = 0 : .Width = Hauptmenue.Feldbreite
                    .Y = 0 : .Height = Hauptmenue.Feldbreite * 2
                End With
                With Grafikengine.ptfRotCenter
                    .X = Hauptmenue.Feldbreite / 2
                    .Y = Hauptmenue.Feldbreite / 2 + Hauptmenue.Feldbreite
                End With
                With Grafikengine.szfScale
                    .Height = Hauptmenue.Feldbreite * 2
                    .Width = Hauptmenue.Feldbreite
                End With
            End If
            If Frames Then
                Grafikengine.recBild.X += ObjektLandschaft.Frame * Hauptmenue.Feldbreite
            End If
            Grafikengine.Sprite.Draw2D(Texturen(BildId), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
        End If
        Return True
    End Function
    Protected Function DrawTerrainUndUntergrund(ByVal Alpha As Integer, ByVal Kriegsnebel As Nebelarten, ByVal BildId As Integer, ByVal X As Integer, ByVal Y As Integer, ByVal Frames As Integer, ByVal MaxFrames As Integer, ByVal TerrainUntergrundID As Integer, ByVal TerrainUntergrundBildID As Integer, ByVal TerrainUntergrundID2 As Integer, ByVal TerrainUntergrundBildID2 As Integer, Optional ByVal FixedLocation As Boolean = False, Optional ByVal Top As Boolean = False) As Boolean
        If TerrainUntergrundID >= 0 And TerrainUntergrundBildID >= 0 Then
            If DataSettings._2D_3D_Malen And Not FixedLocation Then

                Dim intColor As Color = Color.FromArgb(Alpha, 255, 255, 255)
                'pruefen ob wir aus den Screenbereich laufen
                Select Case Kriegsnebel
                    Case Nebelarten.Nebel
                        intColor = Color.FromArgb(Alpha, 180, 180, 180)
                    Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                        intColor = Color.FromArgb(Alpha, 120, 120, 120)
                End Select
                'Zuerst See
                Dim Hoehe As Integer = 0
                Dim Breite As Single = 1
                Dim BreiteStart As Single = 0

                If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Gross Then
                    Hoehe = 1
                End If

                Dim cube(3) As CustomVertex.PositionTextured

                'DC See :(
                If TerrainUntergrundID2 >= 0 Then
                    If Objektverwalter.LandschaftenBilder(TerrainUntergrundID2).Frame Then
                        Breite = 0.25
                        BreiteStart = ObjektLandschaft.Frame / 4
                    Else
                        Breite = 1
                        BreiteStart = 0
                    End If
                    Select Case DataSettings.TerrainStyle
                        Case TerrainStyle.AdvanceWarsDC, TerrainStyle.CommanderWars2
                            cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart, 1)
                            cube(1) = New CustomVertex.PositionTextured(0, 0, 1 + Hoehe, BreiteStart, 0)
                            cube(2) = New CustomVertex.PositionTextured(1, 0, 0, BreiteStart + Breite, 1)
                            cube(3) = New CustomVertex.PositionTextured(1, 0, 1 + Hoehe, BreiteStart + Breite, 0)
                            Grafikengine.malen2Din3D(ObjektSpielfeld.CalcDraw2D3DVec(X, ObjektSpielfeld.SpielfeldLayer.LandschaftenUntergrund, Y), cube, Objektverwalter.LandschaftenBilder(TerrainUntergrundID2).Texturen(TerrainUntergrundBildID2), intColor)
                    End Select
                End If
                If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Frame And Not (Objektverwalter.LandschaftenBilder(TerrainUntergrundID).ID = "SEE" And TerrainUntergrundID2 >= 0 And TerrainUntergrundBildID <> 0) Then
                    Breite = 0.25
                    BreiteStart = ObjektLandschaft.Frame / 4
                Else
                    Breite = 1
                    BreiteStart = 0
                End If


                cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart, 1)
                cube(1) = New CustomVertex.PositionTextured(0, 0, 1 + Hoehe, BreiteStart, 0)
                cube(2) = New CustomVertex.PositionTextured(1, 0, 0, BreiteStart + Breite, 1)
                cube(3) = New CustomVertex.PositionTextured(1, 0, 1 + Hoehe, BreiteStart + Breite, 0)

                Grafikengine.malen2Din3D(ObjektSpielfeld.CalcDraw2D3DVec(X, ObjektSpielfeld.SpielfeldLayer.LandschaftenUntergrund, Y), cube, Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Texturen(TerrainUntergrundBildID), intColor)


                'Dann Terrain
                Hoehe = 0
                Breite = 1
                BreiteStart = 0
                If Gross Then
                    Hoehe = 1
                End If
                If Frame Then
                    If MaxFrames > 0 Then
                        Breite = 1 / MaxFrames
                        BreiteStart = Frames / MaxFrames
                    End If
                End If
                ReDim cube(3)
                cube(0) = New CustomVertex.PositionTextured(0, 0, 0, BreiteStart, 1)
                cube(1) = New CustomVertex.PositionTextured(0, 0, 1 + Hoehe, BreiteStart, 0)
                cube(2) = New CustomVertex.PositionTextured(1, 0, 0, BreiteStart + Breite, 1)
                cube(3) = New CustomVertex.PositionTextured(1, 0, 1 + Hoehe, BreiteStart + Breite, 0)
                Grafikengine.malen2Din3D(ObjektSpielfeld.CalcDraw2D3DVec(X, ObjektSpielfeld.SpielfeldLayer.Landschaften, Y), cube, Texturen(BildId), intColor)

            Else
                Dim sngRotation As Double = 0
                Dim intColor As Color = Color.FromArgb(Alpha, 255, 255, 255)
                'pruefen ob wir aus den Screenbereich laufen
                Select Case Kriegsnebel
                    Case Nebelarten.Nebel
                        intColor = Color.FromArgb(Alpha, 180, 180, 180)
                    Case Nebelarten.Kriegsnebel, Nebelarten.Aufklaerungsnebel
                        intColor = Color.FromArgb(Alpha, 120, 120, 120)
                End Select

                If Not FixedLocation Then
                    'Zuerst See Malen
                    If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Gross = False Then
                        With Grafikengine.recBild
                            .X = 0 : .Width = Hauptmenue.Feldbreite
                            .Y = 0 : .Height = Hauptmenue.Feldbreite
                        End With
                        With Grafikengine.ptfRotCenter
                            .X = Hauptmenue.Feldbreite / 2
                            .Y = Hauptmenue.Feldbreite / 2
                        End With
                        With Grafikengine.szfScale
                            .Height = Hauptmenue.Feldbreite
                            .Width = Hauptmenue.Feldbreite
                        End With
                    Else
                        With Grafikengine.recBild
                            .X = 0 : .Width = Hauptmenue.Feldbreite
                            .Y = 0 : .Height = Hauptmenue.Feldbreite * 2
                        End With
                        With Grafikengine.ptfRotCenter
                            .X = Hauptmenue.Feldbreite / 2
                            .Y = Hauptmenue.Feldbreite / 2 + Hauptmenue.Feldbreite
                        End With
                        With Grafikengine.szfScale
                            .Height = Hauptmenue.Feldbreite * 2
                            .Width = Hauptmenue.Feldbreite
                        End With
                    End If
                    Grafikengine.ptfPosition = New Drawing.Point(Hauptmenue.Feldbreite * X + Objektverwalter.Spielfeld.BildschirmKooX, Hauptmenue.Feldbreite * Y + Objektverwalter.Spielfeld.BildschirmKooY)
                Else
                    If Gross = True And Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Gross = False Then
                        Grafikengine.recBild.Height -= Grafikengine.recBild.Width
                        Grafikengine.szfScale.Height -= Grafikengine.szfScale.Width
                        Grafikengine.ptfPosition = New Drawing.Point(X, Y + Grafikengine.szfScale.Width)
                    Else
                        Grafikengine.ptfPosition = New Drawing.Point(X, Y)
                    End If

                End If
                If TerrainUntergrundID2 >= 0 Then 'DC See :(
                    If Not FixedLocation Then
                        If Objektverwalter.LandschaftenBilder(TerrainUntergrundID2).Frame Then
                            Grafikengine.recBild.X = ObjektLandschaft.Frame * Hauptmenue.Feldbreite
                        Else
                            Grafikengine.recBild.X = 0
                        End If
                        If Not Top Then
                            Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(TerrainUntergrundID2).Texturen(TerrainUntergrundBildID2), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
                        End If
                    ElseIf Not Top Then
                        Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(TerrainUntergrundID2).Texturen(TerrainUntergrundBildID2), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
                    End If
                End If

                If Not FixedLocation Then
                    If Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Frame And Not (Objektverwalter.LandschaftenBilder(TerrainUntergrundID).ID = "SEE" And TerrainUntergrundID2 >= 0 And TerrainUntergrundBildID <> 0) Then
                        Grafikengine.recBild.X = ObjektLandschaft.Frame * Hauptmenue.Feldbreite
                    Else
                        Grafikengine.recBild.X = 0
                    End If
                End If
                If Not Top Then
                    Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Texturen(TerrainUntergrundBildID), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
                End If
                If Not FixedLocation Then
                    If Gross = False Then
                        With Grafikengine.recBild
                            .X = 0 : .Width = Hauptmenue.Feldbreite
                            .Y = 0 : .Height = Hauptmenue.Feldbreite
                        End With
                        With Grafikengine.ptfRotCenter
                            .X = Hauptmenue.Feldbreite / 2
                            .Y = Hauptmenue.Feldbreite / 2
                        End With
                        With Grafikengine.szfScale
                            .Height = Hauptmenue.Feldbreite
                            .Width = Hauptmenue.Feldbreite
                        End With
                    Else
                        With Grafikengine.recBild
                            .X = 0 : .Width = Hauptmenue.Feldbreite
                            .Y = 0 : .Height = Hauptmenue.Feldbreite * 2
                        End With
                        With Grafikengine.ptfRotCenter
                            .X = Hauptmenue.Feldbreite / 2
                            .Y = Hauptmenue.Feldbreite / 2 + Hauptmenue.Feldbreite
                        End With
                        With Grafikengine.szfScale
                            .Height = Hauptmenue.Feldbreite * 2
                            .Width = Hauptmenue.Feldbreite
                        End With
                    End If
                    If Frame Then
                        Grafikengine.recBild.X = Frames * Hauptmenue.Feldbreite
                    End If
                Else
                    If Gross = True And Objektverwalter.LandschaftenBilder(TerrainUntergrundID).Gross = False Then
                        Grafikengine.recBild.Height += Grafikengine.recBild.Width
                        Grafikengine.szfScale.Height += Grafikengine.szfScale.Width
                        Grafikengine.ptfPosition = New Drawing.Point(X, Y)
                    End If
                End If
                If Top Or FixedLocation Then
                    Grafikengine.Sprite.Draw2D(Texturen(BildId), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
                End If
            End If
            Return True
        Else
            Return False
        End If
    End Function
    ''' <summary>
    ''' Returns the Terrain that can be under this Terrain
    ''' </summary>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Overridable Function GetTerrainUntergrund() As String()
        Return New String() {}
    End Function
#End Region
#Region "Uebergaenge"
    Protected Sub UebergaengeLaden(ByVal Uebergang As String)
        Select Case Uebergang.ToUpper
            Case "FLUSSMUENDUNG"
                Flussmuendung()
            Case "SCHNEE"
                Schnee()
            Case "WUESTE"
                Wueste()
            Case "STRAND"
                Strand()
            Case "KUESTE"
                Kueste()
            Case "SUMPF"
                Sumpf()
        End Select
    End Sub
    ''' <summary>
    ''' Laedt den Uebergang Flussmuendung
    ''' </summary>
    ''' <remarks></remarks>
    Private Sub Flussmuendung()
        UebergangsModus = Uebergangsmodi.VierAngrenzenden
        UebergangsAusrichtungslandschaften = New String() {"SEE", "RIFF", "RAUESEE", "NEBEL"}
        Array.Resize(Uebergaenge, 4)
        Dim Ordner As String = ObjektLadeklasse.GetOrdner
        If Not My.Computer.FileSystem.FileExists(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Flussmuendung+S.png") Then Ordner = "CW\"
        Uebergaenge(0) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Flussmuendung+S.png")
        Uebergaenge(1) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Flussmuendung+N.png")
        Uebergaenge(2) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Flussmuendung+O.png")
        Uebergaenge(3) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Flussmuendung+W.png")
        Uebergangfunktion = New String() {"S", "N", "O", "W"}
    End Sub
    ''' <summary>
    ''' Laedt den Uebergang Wueste
    ''' </summary>
    ''' <remarks></remarks>
    Private Sub Wueste()
        Dim Ordner As String = ObjektLadeklasse.GetOrdner
        UebergangsModus = Uebergangsmodi.VierAngrenzenden
        UebergangsAusrichtungslandschaften = New String() {"EBENE", "EBENE+SCHROTT", "STRASSE", "SUMPF"}
        Array.Resize(Uebergaenge, 4)
        If Not My.Computer.FileSystem.FileExists(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Wueste+S.png") Then Ordner = "CW\"
        Uebergaenge(0) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Wueste+S.png")
        Uebergaenge(1) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Wueste+N.png")
        Uebergaenge(2) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Wueste+O.png")
        Uebergaenge(3) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Wueste+W.png")
        Uebergangfunktion = New String() {"S", "N", "O", "W"}
    End Sub
    ''' <summary>
    ''' Laedt den Uebergang Wueste
    ''' </summary>
    ''' <remarks></remarks>
    Private Sub Strand()
        Dim Ordner As String = ObjektLadeklasse.GetOrdner
        UebergangsModus = Uebergangsmodi.Strand
        UebergangsAusrichtungslandschaften = New String() {"EBENE", "LASER", "PLASMA", "FEUER", "METEOR", "OEDLAND", "RUINE", "SUMPF", "WALD", "BERG", "STRASSE", "WUESTE", "PIPELINE", "EBENE+SCHROTT", "HQ", "STADT", "BASIS", "WERFT", "FLUGHAFEN", "FABRIK", "TURM", "SCHWEISSNAHT", "KRISTALL", "MONOLITH", "MAUER", "PIPE", "PIPESCHWEISS", "KAPUTTEPIPESCHWEISS", "KAPUTTESCHWEISSNAHT", "KAKTEEN", "FELSEN", "AUSGETROCKNETESFLUSSBETT", "PFAD", "MINIGESCHUETZ+N", "MINIGESCHUETZ+O", "MINIGESCHUETZ+S", "MINIGESCHUETZ+W", "SCHWARZE GESCHUETZ+N", "SCHWARZE GESCHUETZ+O", "SCHWARZE GESCHUETZ+S", "SCHWARZE GESCHUETZ+W", "VULKAN", "FESTUNG", "OMEGARAKETE", "MINE", "WUESTE+SCHROTT", "SCHNEE+SCHROTT", "RAKETENSILO+RAKETE", "RAKETENSILO", "SCHNEE", "KIEFERN", "GIPFEL", "STRASSENFROST", "PLINEKAPUTT", "PLINE", "PLINESCHWEISS", "PIPESTATION", "SCHOCKLASER+N", "SCHOCKLASER+O", "SCHOCKLASER+S", "SCHOCKLASER+W"}
        Array.Resize(Uebergaenge, 8)
        If Not My.Computer.FileSystem.FileExists(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Strand+NW.png") Then Ordner = "CW\"
        Uebergaenge(0) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Strand+NW.png")
        Uebergaenge(1) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Strand+NO.png")
        Uebergaenge(2) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Strand+SO.png")
        Uebergaenge(3) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Strand+SW.png")
        Uebergaenge(4) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Strand+ON.png")
        Uebergaenge(5) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Strand+OS.png")
        Uebergaenge(6) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Strand+WS.png")
        Uebergaenge(7) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Strand+WN.png")
        Uebergangfunktion = New String() {"NW", "NO", "SO", "SW", "ON", "OS", "WS", "WN"}
    End Sub
    ''' <summary>
    ''' Laedt den Uebergang Kueste
    ''' </summary>
    ''' <remarks></remarks>
    Private Sub Kueste()
        Dim Ordner As String = ObjektLadeklasse.GetOrdner
        UebergangsModus = Uebergangsmodi.NichtNurEcken
        UebergangsAusrichtungslandschaften = New String() {"SEE", "RIFF", "STRAND", "BRUECKE", "ZUGBRUECKE", "BAUBRUECKE", "RAUESEE", "NEBEL"}
        Array.Resize(Uebergaenge, 4)
        If Not My.Computer.FileSystem.FileExists(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Kueste+NW.png") Then Ordner = "CW\"
        Uebergaenge(0) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Kueste+NO.png")
        Uebergaenge(1) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Kueste+NW.png")
        Uebergaenge(2) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Kueste+SW.png")
        Uebergaenge(3) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Kueste+OS.png")
        Uebergangfunktion = New String() {"NO", "NW", "SW", "OS"}
    End Sub
    ''' <summary>
    ''' Laedt den Uebergang Schnee
    ''' </summary>
    ''' <remarks></remarks>
    Private Sub Schnee()
        Dim Ordner As String = ObjektLadeklasse.GetOrdner
        UebergangsModus = Uebergangsmodi.VierAngrenzenden
        UebergangsAusrichtungslandschaften = New String() {"EBENE", "SUMPF", "EBENE+SCHROTT", "STRASSE", "WUESTE", "PFAD", "WUESTE+SCHROTT"}
        Array.Resize(Uebergaenge, 4)
        If Not My.Computer.FileSystem.FileExists(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Schnee+S.png") Then Ordner = "CW\"
        Uebergaenge(0) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Schnee+S.png")
        Uebergaenge(1) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Schnee+N.png")
        Uebergaenge(2) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Schnee+O.png")
        Uebergaenge(3) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "Schnee+W.png")
        Uebergangfunktion = New String() {"S", "N", "O", "W"}
    End Sub
    ''' <summary>
    ''' Laedt den Uebergang Sumpf
    ''' </summary>
    ''' <remarks></remarks>
    Private Sub Sumpf()
        Dim Ordner As String = ObjektLadeklasse.GetOrdner
        UebergangsModus = Uebergangsmodi.VierAngrenzenden
        UebergangsAusrichtungslandschaften = New String() {"EBENE", "EBENE+SCHROTT", "STRASSE"}
        Array.Resize(Uebergaenge, 4)
        If Not My.Computer.FileSystem.FileExists(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "SUMPF+S.png") Then Ordner = "CW\"
        Uebergaenge(0) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "SUMPF+S.png")
        Uebergaenge(1) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "SUMPF+N.png")
        Uebergaenge(2) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "SUMPF+O.png")
        Uebergaenge(3) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Terrain\Transition\" + Ordner + "SUMPF+W.png")
        Uebergangfunktion = New String() {"S", "N", "O", "W"}
    End Sub
#End Region
    ''' <summary>
    ''' Returns the ID inside the Terrain Array
    ''' </summary>
    ''' <param name="ID"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Shared Function GetID(ByVal ID As String) As Integer
        For I = 0 To Objektverwalter.LandschaftenBilder.Length - 1
            If Objektverwalter.LandschaftenBilder(I).ID = ID Then
                Return I
            End If
        Next
        Return 0
    End Function

    ''' <summary>
    ''' Ist jetzt eine Extra funktion, die nur das "+N+S+W" usw. zurueckgibt, damit ichs fuers 3D verwenden kann.
    ''' </summary>
    ''' <param name="X"></param>
    ''' <param name="Y"></param>
    ''' <param name="Spielfeld"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Function getAusrichtung(ByVal X As Integer, ByVal Y As Integer, ByVal Spielfeld As ObjektSpielfeld) As String
        Dim Ausrichtungen As String = ""
        If IsNothing(Spielfeld) = False Then
            If Not Spielfeld.Landschaften(Spielfeld.Breite - 1, Spielfeld.Hoehe - 1, ObjektSpielfeld.Bodenschlacht) Is Nothing Then
                If Y - 1 >= 0 Then
                    If FindElement(Ausrichtungslandschaften, Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                        Ausrichtungen += "+N"
                    End If
                End If
                If X + 1 < Spielfeld.Breite Then
                    If FindElement(Ausrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                        Ausrichtungen += "+O"
                    End If
                End If
                If Y + 1 < Spielfeld.Hoehe Then
                    If FindElement(Ausrichtungslandschaften, Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                        Ausrichtungen += "+S"
                    End If
                End If
                If X - 1 >= 0 Then
                    If FindElement(Ausrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                        Ausrichtungen += "+W"
                    End If
                End If
            End If
        End If
        Select Case ID
            Case "SEE"
                'Wir machen nichts
            Case "RIFF"
                Ausrichtungen = AddRandAusrichtung(X, Y, Ausrichtungen, Spielfeld)
            Case "RAUESEE"
                Ausrichtungen = AddRandAusrichtung(X, Y, Ausrichtungen, Spielfeld)
            Case "NEBEL"
                Ausrichtungen = AddRandAusrichtung(X, Y, Ausrichtungen, Spielfeld)
            Case Else
                If Ausrichtungen.Length <= 2 Then
                    Ausrichtungen = AddRandAusrichtung(X, Y, Ausrichtungen, Spielfeld)
                End If
        End Select
        If SekundärAusrichtungslandschaften.Length > 0 Then
            Ausrichtungen += "_"
            If IsNothing(Spielfeld) = False Then
                If Not Spielfeld.Landschaften(Spielfeld.Breite - 1, Spielfeld.Hoehe - 1, ObjektSpielfeld.Bodenschlacht) Is Nothing Then
                    If Y - 1 >= 0 Then
                        If FindElement(SekundärAusrichtungslandschaften, Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                            Ausrichtungen += "+N"
                        End If
                    End If
                    If X + 1 < Spielfeld.Breite Then
                        If FindElement(SekundärAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                            Ausrichtungen += "+O"
                        End If
                    End If
                    If Y + 1 < Spielfeld.Hoehe Then
                        If FindElement(SekundärAusrichtungslandschaften, Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                            Ausrichtungen += "+S"
                        End If
                    End If
                    If X - 1 >= 0 Then
                        If FindElement(SekundärAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                            Ausrichtungen += "+W"
                        End If
                    End If
                End If
            End If
        End If
        Return Ausrichtungen
    End Function
    ''' <summary>
    ''' Ist jetzt eine Extra funktion, die nur das "+N+S+W" usw. zurueckgibt, damit ichs fuers 3D verwenden kann.
    ''' </summary>
    ''' <param name="X"></param>
    ''' <param name="Y"></param>
    ''' <param name="Spielfeld"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Function getAusrichtungUntergrund(ByVal X As Integer, ByVal Y As Integer, ByVal Spielfeld As ObjektSpielfeld) As String
        If Spielfeld.Landschaften(X, Y, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID < 0 Then Return ""
        Dim Ausrichtungslandschaften() As String = Objektverwalter.LandschaftenBilder(Spielfeld.Landschaften(X, Y, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID).Ausrichtungslandschaften
        Dim Ausrichtungen As String = ""
        If IsNothing(Spielfeld) = False Then
            If Not Spielfeld.Landschaften(Spielfeld.Breite - 1, Spielfeld.Hoehe - 1, ObjektSpielfeld.Bodenschlacht) Is Nothing Then
                If Y - 1 >= 0 Then
                    If Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID >= 0 Then
                        If FindElement(Ausrichtungslandschaften, Objektverwalter.LandschaftenBilder(Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID).ID, True) >= 0 Then
                            Ausrichtungen += "+N"
                        ElseIf FindElement(Ausrichtungslandschaften, Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                            Ausrichtungen += "+N"
                        End If
                    Else
                        If FindElement(Ausrichtungslandschaften, Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                            Ausrichtungen += "+N"
                        End If
                    End If
                End If
                If X + 1 < Spielfeld.Breite Then
                    If Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID >= 0 Then
                        If FindElement(Ausrichtungslandschaften, Objektverwalter.LandschaftenBilder(Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID).ID, True) >= 0 Then
                            Ausrichtungen += "+O"
                        ElseIf FindElement(Ausrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                            Ausrichtungen += "+O"
                        End If
                    Else
                        If FindElement(Ausrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                            Ausrichtungen += "+O"
                        End If
                    End If
                End If
                If Y + 1 < Spielfeld.Hoehe Then
                    If Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID >= 0 Then
                        If FindElement(Ausrichtungslandschaften, Objektverwalter.LandschaftenBilder(Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID).ID, True) >= 0 Then
                            Ausrichtungen += "+S"
                        ElseIf FindElement(Ausrichtungslandschaften, Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                            Ausrichtungen += "+S"
                        End If
                    Else
                        If FindElement(Ausrichtungslandschaften, Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                            Ausrichtungen += "+S"
                        End If
                    End If
                End If
                If X - 1 >= 0 Then
                    If Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID >= 0 Then
                        If FindElement(Ausrichtungslandschaften, Objektverwalter.LandschaftenBilder(Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID).ID, True) >= 0 Then
                            Ausrichtungen += "+W"
                        ElseIf FindElement(Ausrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                            Ausrichtungen += "+W"
                        End If
                    Else
                        If FindElement(Ausrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                            Ausrichtungen += "+W"
                        End If
                    End If
                End If
            End If
        End If
        Select Case Spielfeld.Landschaften(X, Y, ObjektSpielfeld.Bodenschlacht).LandschaftsID
            Case "STRAND"
                Ausrichtungen = ""
            Case "BRUECKE"
            Case "SEE"
                If Spielfeld.Landschaften(X, Y, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID2 < 0 Then
                    Ausrichtungen = ""
                End If
            Case "RIFF"
                'Ausrichtungen = AddRandAusrichtung(X, Y, Ausrichtungen, Spielfeld)
            Case "RAUESEE"
                'Ausrichtungen = AddRandAusrichtung(X, Y, Ausrichtungen, Spielfeld)
            Case "NEBEL"
                'Ausrichtungen = AddRandAusrichtung(X, Y, Ausrichtungen, Spielfeld)
            Case Else
                If Ausrichtungen.Length <= 2 Then
                    Ausrichtungen = AddRandAusrichtung(X, Y, Ausrichtungen, Spielfeld)
                End If
        End Select
        If SekundärAusrichtungslandschaften.Length > 0 Then
            If IsNothing(Spielfeld) = False Then
                If Not Spielfeld.Landschaften(Spielfeld.Breite - 1, Spielfeld.Hoehe - 1, ObjektSpielfeld.Bodenschlacht) Is Nothing Then
                    If Y - 1 >= 0 Then
                        If Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID >= 0 Then
                            If FindElement(SekundärAusrichtungslandschaften, Objektverwalter.LandschaftenBilder(Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID).ID, True) >= 0 Then
                                Ausrichtungen += "+N"
                            ElseIf FindElement(SekundärAusrichtungslandschaften, Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                Ausrichtungen += "+N"
                            End If
                        Else
                            If FindElement(SekundärAusrichtungslandschaften, Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                Ausrichtungen += "+N"
                            End If
                        End If
                    End If
                    If X + 1 < Spielfeld.Breite Then
                        If Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID >= 0 Then
                            If FindElement(SekundärAusrichtungslandschaften, Objektverwalter.LandschaftenBilder(Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID).ID, True) >= 0 Then
                                Ausrichtungen += "+O"
                            ElseIf FindElement(SekundärAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                Ausrichtungen += "+O"
                            End If
                        Else
                            If FindElement(SekundärAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                Ausrichtungen += "+O"
                            End If
                        End If
                    End If
                    If Y + 1 < Spielfeld.Hoehe Then
                        If Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID >= 0 Then
                            If FindElement(SekundärAusrichtungslandschaften, Objektverwalter.LandschaftenBilder(Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID).ID, True) >= 0 Then
                                Ausrichtungen += "+S"
                            ElseIf FindElement(SekundärAusrichtungslandschaften, Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                Ausrichtungen += "+S"
                            End If
                        Else
                            If FindElement(SekundärAusrichtungslandschaften, Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                Ausrichtungen += "+S"
                            End If
                        End If
                    End If
                    If X - 1 >= 0 Then
                        If Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID >= 0 Then
                            If FindElement(SekundärAusrichtungslandschaften, Objektverwalter.LandschaftenBilder(Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID).ID, True) >= 0 Then
                                Ausrichtungen += "+W"
                            ElseIf FindElement(SekundärAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                Ausrichtungen += "+W"
                            End If
                        Else
                            If FindElement(SekundärAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                Ausrichtungen += "+W"
                            End If
                        End If
                    End If
                End If
            End If
        End If
        Return Ausrichtungen
    End Function
    Public Function AddRandAusrichtung(ByVal X As Integer, ByVal Y As Integer, ByVal Ausrichtungen As String, ByVal Spielfeld As ObjektSpielfeld) As String
        If Y - 1 < 0 Then
            Ausrichtungen = "+N" + Ausrichtungen
        End If
        If X + 1 >= Spielfeld.Breite Then
            If Ausrichtungen.StartsWith("+N") Then
                If Ausrichtungen.Contains("+S") Then
                    Ausrichtungen = "+N+O" + Ausrichtungen.Remove(0, 2)
                ElseIf Ausrichtungen.Contains("+W") Then
                    Ausrichtungen = "+N+O" + Ausrichtungen.Remove(0, 2)
                Else
                    Ausrichtungen += "+O"
                End If
            Else
                Ausrichtungen = "+O" + Ausrichtungen
            End If
        End If
        If Y + 1 >= Spielfeld.Hoehe Then
            If Ausrichtungen.StartsWith("+W") Then
                Ausrichtungen = "+S" + Ausrichtungen
            ElseIf Ausrichtungen.EndsWith("+W") Then
                Ausrichtungen = Ausrichtungen.Remove(Ausrichtungen.Length - 2) + "+S+W"
            Else
                Ausrichtungen += "+S"
            End If
        End If
        If X - 1 < 0 Then
            Ausrichtungen += "+W"
        End If
        Return Ausrichtungen
    End Function
    Public Function AusrichtungInvertieren(ByVal Ausrichtung As String) As String
        Ausrichtung = Ausrichtung.ToLower
        Dim N As Boolean = Ausrichtung.Contains("n")
        Dim O As Boolean = Ausrichtung.Contains("o")
        Dim S As Boolean = Ausrichtung.Contains("s")
        Dim W As Boolean = Ausrichtung.Contains("w")
        Dim Ergebnis As String = ""
        If Not N Then Ergebnis += "+N"
        If Not O Then Ergebnis += "+O"
        If Not S Then Ergebnis += "+S"
        If Not W Then Ergebnis += "+W"
        Return Ergebnis
    End Function
    Public Function AusrichtungVereinfachen(ByVal Ausrichtung As String, ByRef Rotation As Single) As String
        Rotation = 0
        If Not Ausrichtung = "" Then
            Select Case Ausrichtung.ToUpper
                Case "+N"
                    Rotation = 0
                    Ausrichtung = "+N"
                Case "+O"
                    Rotation = Math.PI / 2
                    Ausrichtung = "+N"
                Case "+S"
                    Rotation = Math.PI
                    Ausrichtung = "+N"
                Case "+W"
                    Rotation = Math.PI * 3 / 2
                    Ausrichtung = "+N"

                Case "+N+O"
                    Rotation = 0
                    Ausrichtung = "+N+O"
                Case "+O+S"
                    Rotation = Math.PI / 2
                    Ausrichtung = "+N+O"
                Case "+S+W"
                    Rotation = Math.PI
                    Ausrichtung = "+N+O"
                Case "+N+W"
                    Rotation = Math.PI * 3 / 2
                    Ausrichtung = "+N+O"

                Case "+N+S"
                    Rotation = 0
                    Ausrichtung = "+N+S"
                Case "+O+W"
                    Rotation = Math.PI / 2
                    Ausrichtung = "+N+S"

                Case "+N+O+S"
                    Rotation = 0
                    Ausrichtung = "+N+O+S"
                Case "+O+S+W"
                    Rotation = Math.PI / 2
                    Ausrichtung = "+N+O+S"
                Case "+N+S+W"
                    Rotation = Math.PI
                    Ausrichtung = "+N+O+S"
                Case "+N+O+W"
                    Rotation = Math.PI * 3 / 2
                    Ausrichtung = "+N+O+S"

                Case "+N+O+S+W"
                    Rotation = 0
                    Ausrichtung = "+N+O+S+W"
            End Select
        End If
        Return Ausrichtung
    End Function
    ''' <summary>
    ''' Ist jetzt eine Extra funktion, die nur das "+N+S+W" usw. zurueckgibt, damit ichs fuers 3D verwenden kann. Vereinfacht heisst, dass nicht mehr +O zurueckgegeben wird, sondern +N und eine Rotation um 90°
    ''' </summary>
    ''' <param name="X"></param>
    ''' <param name="Y"></param>
    ''' <param name="Spielfeld"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Function getAusrichtungVereinfacht(ByVal X As Integer, ByVal Y As Integer, ByVal Spielfeld As ObjektSpielfeld, ByRef Rotation As Single) As String
        Dim Ausrichtung As String = getAusrichtung(X, Y, Spielfeld)
        Return AusrichtungVereinfachen(Ausrichtung, Rotation)
    End Function
    Public Overridable Function BildID(ByVal X As Integer, ByVal Y As Integer, ByVal Spielfeld As ObjektSpielfeld, Optional ByVal Untergund As Boolean = False) As Integer
        Dim Ausrichtungen As String = ""
        If Untergund Then
            Ausrichtungen = getAusrichtungUntergrund(X, Y, Spielfeld)
            If Spielfeld.Landschaften(X, Y, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID < 0 Then Return 0
            Dim Normal As Integer = Objektverwalter.LandschaftenBilder(Spielfeld.Landschaften(X, Y, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID).Normal
            If Ausrichtungen = "" Then
                If Normal < 0 Then
                    Return -1
                Else
                    Return Zufallszahl(0, Normal)
                End If
            Else
                If Ausrichtungen.StartsWith("+") Then
                    Ausrichtungen = Ausrichtungen.Remove(0, 1)
                End If
                Dim Stelle As Integer = FindElement(Ausrichtung, Ausrichtungen, True)
                If Stelle < 0 Then
                    If Normal < 0 Then
                        Return -1
                    Else
                        Return Zufallszahl(0, Normal)
                    End If
                Else
                    Return Stelle
                End If
            End If
        Else
            Ausrichtungen = getAusrichtung(X, Y, Spielfeld)
            If Ausrichtungen = "" Then
                If Normal < 0 Then
                    Return -1
                Else
                    Return Zufallszahl(0, Normal)
                End If
            Else
                If Ausrichtungen.StartsWith("+") Then
                    Ausrichtungen = Ausrichtungen.Remove(0, 1)
                End If
                Dim Stelle As Integer = FindElement(Ausrichtung, Ausrichtungen, True)
                If Stelle < 0 Then
                    If Normal < 0 Then
                        Return -1
                    Else
                        Return Zufallszahl(0, Normal)

                    End If
                Else
                    Return Stelle
                End If
            End If
        End If

    End Function
    Public Function UebergangsID(ByVal X As Integer, ByVal Y As Integer, ByVal Spielfeld As ObjektSpielfeld) As Integer()
        Dim Rueckgabe() As Integer = {}
        If IsNothing(Spielfeld) = False And Not Spielfeld.Landschaften(Spielfeld.Breite - 1, Spielfeld.Hoehe - 1, ObjektSpielfeld.Bodenschlacht) Is Nothing Then
            If UebergangsModus = Uebergangsmodi.Keiner Then
                Return Rueckgabe
            Else
                If UebergangsModus = Uebergangsmodi.VierAngrenzenden Or UebergangsModus = Uebergangsmodi.NichtVierAngrenzenden Then
                    Dim Ausrichtung As String = ""
                    For I = 0 To 3
                        Select Case I
                            Case 0
                                Ausrichtung = "N"
                                Y -= 1
                            Case 1
                                Ausrichtung = "O"
                                Y += 1
                                X += 1
                            Case 2
                                Ausrichtung = "S"
                                X -= 1
                                Y += 1
                            Case 3
                                Ausrichtung = "W"
                                Y -= 1
                                X -= 1
                        End Select
                        If X >= 0 And Y >= 0 And X < Spielfeld.Breite And Y < Spielfeld.Hoehe Then
                            If UebergangsModus = Uebergangsmodi.VierAngrenzenden Then
                                If Spielfeld.Landschaften(X, Y, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID >= 0 Then

                                    If FindElement(UebergangsAusrichtungslandschaften, Objektverwalter.LandschaftenBilder(Spielfeld.Landschaften(X, Y, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID).ID, True) >= 0 And Objektverwalter.LandschaftenBilder(Spielfeld.Landschaften(X, Y, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID).ID <> "SEE" Then
                                        Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                        Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, Ausrichtung)
                                    ElseIf FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                        Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                        Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, Ausrichtung)
                                    End If
                                ElseIf FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                    Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                    Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, Ausrichtung)
                                End If
                            Else
                                If Spielfeld.Landschaften(X, Y, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID >= 0 Then
                                    If FindElement(UebergangsAusrichtungslandschaften, Objektverwalter.LandschaftenBilder(Spielfeld.Landschaften(X, Y, ObjektSpielfeld.Bodenschlacht).TerrainUntergrundID).ID, True) < 0 Then
                                        Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                        Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, Ausrichtung)
                                    ElseIf FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 Then
                                        Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                        Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, Ausrichtung)
                                    End If
                                ElseIf FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 Then
                                    Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                    Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, Ausrichtung)
                                End If
                            End If
                        End If
                    Next
                ElseIf UebergangsModus = Uebergangsmodi.NurEcken Or UebergangsModus = Uebergangsmodi.NichtNurEcken Then
                    If Y - 1 >= 0 And X + 1 < Spielfeld.Breite Then
                        If UebergangsModus = Uebergangsmodi.NurEcken Then
                            If FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 And FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 Then
                                If FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                    Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                    Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "NO")
                                End If
                            End If
                        Else
                            If FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 And FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                If FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 Then
                                    Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                    Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "NO")
                                End If
                            End If
                        End If
                    End If
                    If Y + 1 < Spielfeld.Hoehe And X + 1 < Spielfeld.Breite Then
                        If UebergangsModus = Uebergangsmodi.NurEcken Then
                            If FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 And FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 Then
                                If FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                    Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                    Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "OS")
                                End If
                            End If
                        Else
                            If FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 And FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                If FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 Then
                                    Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                    Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "OS")
                                End If
                            End If
                        End If
                    End If
                    If Y + 1 < Spielfeld.Hoehe And X - 1 >= 0 Then
                        If UebergangsModus = Uebergangsmodi.NurEcken Then
                            If FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 And FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 Then
                                If FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                    Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                    Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "SW")
                                End If
                            End If
                        Else
                            If FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 And FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                If FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y + 1, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 Then
                                    Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                    Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "SW")
                                End If
                            End If
                        End If
                    End If
                    If Y - 1 >= 0 And X - 1 >= 0 Then
                        If UebergangsModus = Uebergangsmodi.NurEcken Then
                            If FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 And FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 Then
                                If FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                    Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                    Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "NW")
                                End If
                            End If
                        Else
                            If FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 And FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).getID, True) >= 0 Then
                                If FindElement(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y - 1, ObjektSpielfeld.Bodenschlacht).getID, True) < 0 Then
                                    Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                    Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "NW")
                                End If
                            End If
                        End If
                    End If
                ElseIf UebergangsModus = Uebergangsmodi.Strand Then
                    If Y - 1 >= 0 Then
                        If Spielfeld.Landschaften(X, Y - 1, ObjektSpielfeld.Bodenschlacht).getID = "STRAND" Then
                            If X - 1 >= 0 Then
                                If Array.IndexOf(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y - 1, ObjektSpielfeld.Bodenschlacht).getID) >= 0 Then
                                    Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                    Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "WN")
                                End If
                            ElseIf Not ID = "SEE" Then
                                Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "WN")
                            End If
                            If X + 1 < Spielfeld.Breite Then
                                If Array.IndexOf(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y - 1, ObjektSpielfeld.Bodenschlacht).getID) >= 0 Then
                                    Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                    Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "ON")
                                End If
                            ElseIf Not ID = "SEE" Then
                                Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "ON")
                            End If
                        End If
                    End If
                    If Y + 1 < Spielfeld.Hoehe Then
                        If Spielfeld.Landschaften(X, Y + 1, ObjektSpielfeld.Bodenschlacht).getID = "STRAND" Then
                            If X - 1 >= 0 Then
                                If Array.IndexOf(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y + 1, ObjektSpielfeld.Bodenschlacht).getID) >= 0 Then
                                    Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                    Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "WS")
                                End If
                            ElseIf Not ID = "SEE" Then
                                Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "WS")
                            End If
                            If X + 1 < Spielfeld.Breite Then
                                If Array.IndexOf(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y + 1, ObjektSpielfeld.Bodenschlacht).getID) >= 0 Then
                                    Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                    Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "OS")
                                End If
                            ElseIf Not ID = "SEE" Then
                                Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "OS")
                            End If
                        End If
                    End If
                    If X - 1 >= 0 Then
                        If Spielfeld.Landschaften(X - 1, Y, ObjektSpielfeld.Bodenschlacht).getID = "STRAND" Then
                            If Y - 1 >= 0 Then
                                If Array.IndexOf(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y - 1, ObjektSpielfeld.Bodenschlacht).getID) >= 0 Then
                                    Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                    Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "NW")
                                End If
                            ElseIf Not ID = "SEE" Then
                                Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "NW")
                            End If
                            If Y + 1 < Spielfeld.Hoehe Then
                                If Array.IndexOf(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X - 1, Y + 1, ObjektSpielfeld.Bodenschlacht).getID) >= 0 Then
                                    Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                    Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "SW")
                                End If
                            ElseIf Not ID = "SEE" Then
                                Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "SW")
                            End If
                        End If
                    End If
                    If X + 1 < Spielfeld.Breite Then
                        If Spielfeld.Landschaften(X + 1, Y, ObjektSpielfeld.Bodenschlacht).getID = "STRAND" Then
                            If Y - 1 >= 0 Then
                                If Array.IndexOf(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y - 1, ObjektSpielfeld.Bodenschlacht).getID) >= 0 Then
                                    Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                    Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "NO")
                                End If
                            ElseIf Not ID = "SEE" Then
                                Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "NO")
                            End If
                            If Y + 1 < Spielfeld.Hoehe Then
                                If Array.IndexOf(UebergangsAusrichtungslandschaften, Spielfeld.Landschaften(X + 1, Y + 1, ObjektSpielfeld.Bodenschlacht).getID) >= 0 Then
                                    Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                    Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "SO")
                                End If
                            ElseIf Not ID = "SEE" Then
                                Array.Resize(Rueckgabe, Rueckgabe.Length + 1)
                                Rueckgabe(Rueckgabe.Length - 1) = FindElement(Uebergangfunktion, "SO")
                            End If
                        End If
                    End If
                End If
            End If
        End If
        Return Rueckgabe
    End Function

    Public Sub Malen3D(ByVal p_MatCube As Microsoft.DirectX.Matrix, ByVal ID As String, Optional ByVal Landschaft As ObjektLandschaft = Nothing)
        For i = 0 To Objektverwalter.LandschaftenBilder.Length - 1
            If Objektverwalter.LandschaftenBilder(i).ID.ToUpper = ID.ToUpper Then
                Objektverwalter.LandschaftenBilder(i).Malen3D(p_MatCube, Landschaft)
                Exit Sub
            End If
        Next
    End Sub

    ''' <summary>
    ''' Gibt die Position zurueck, wo Einheiten hingemalt werden sollen. (Meistens 0.5 in X und Z-Richtung)
    ''' </summary>
    ''' <param name="Pos"> Die Art wie sie stehen soll. "LAND", "LUFT" oder "WASSER"</param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Overridable Function getFigurPos(ByVal Pos As Positionsarten) As Vector3
        Select Case Pos
            Case Positionsarten.Boden
                Return New Vector3(0.5, 0, 0.5)
            Case Positionsarten.Luft
                Return New Vector3(0.5, 1, 0.5)
            Case Positionsarten.Wasser
                Return New Vector3(0.5, 0, 0.5)
            Case Else
                Return New Vector3(0.5, 0, 0.5)
        End Select
    End Function
    Public MustOverride Sub Malen3D(ByVal p_MatCube As Microsoft.DirectX.Matrix, ByVal Landschaft As ObjektLandschaft)
    Public MustOverride Sub Ini3D()
    Public MustOverride Sub Tick()
    Public Overridable Function getMesh() As Mesh
        Return Nothing
    End Function
    Public Sub Reset()
        For i = 0 To Texturen.Length - 1
            Texturen(i).Dispose()
            Texturen(i) = Nothing
        Next
        For i = 0 To Uebergaenge.Length - 1
            Uebergaenge(i).Dispose()
            Uebergaenge(i) = Nothing
        Next
        Grafikengine.Grafikkarte.EvictManagedResources()
    End Sub
End Class
